#!/usr/bin/env bash
# 中文评审脚本 - 包含钉钉通知

# 先设置错误处理
set -euo pipefail

# 错误处理函数
error_handler() {
  local line_num=$1
  local exit_code=$2
  # 获取脚本目录
  local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
  # 确保日志目录存在
  local error_log_dir="$script_dir/logs/debug"
  mkdir -p "$error_log_dir"
  local error_log="${DEBUG_LOG:-$error_log_dir/pr_review_error_$(date +%Y%m%d_%H%M%S).log}"
  
  echo -e "\033[0;31m[ERROR] 脚本在第 $line_num 行失败，退出码: $exit_code\033[0m" >&2
  echo "[ERROR] 脚本在第 $line_num 行失败，退出码: $exit_code" >> "$error_log"
  echo -e "\033[0;31m调试信息已保存到: $error_log\033[0m" >&2
  
  # 如果是调试模式，显示最后几行日志
  if [[ "${DEBUG_MODE:-false}" == "true" ]]; then
    echo -e "\033[0;33m最后的日志内容：\033[0m" >&2
    tail -n 20 "$error_log" >&2
  fi
  
  exit $exit_code
}

# 设置错误处理trap
trap 'error_handler $LINENO $?' ERR

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'

# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# 日志函数
log_debug() {
  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
  local default_log="$SCRIPT_DIR/logs/debug/pr_review_debug_$(date +%Y%m%d).log"
  mkdir -p "$(dirname "$default_log")"
  echo -e "${CYAN}[DEBUG][$timestamp] $1${NC}" >&2
  echo "[$timestamp][DEBUG] $1" >> "${DEBUG_LOG:-$default_log}"
}

log_error() {
  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
  local default_log="$SCRIPT_DIR/logs/debug/pr_review_debug_$(date +%Y%m%d).log"
  mkdir -p "$(dirname "$default_log")"
  echo -e "${RED}[ERROR][$timestamp] $1${NC}" >&2
  echo "[$timestamp][ERROR] $1" >> "${DEBUG_LOG:-$default_log}"
}

log_info() {
  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
  local default_log="$SCRIPT_DIR/logs/debug/pr_review_debug_$(date +%Y%m%d).log"
  mkdir -p "$(dirname "$default_log")"
  echo -e "${GREEN}[INFO][$timestamp] $1${NC}"
  echo "[$timestamp][INFO] $1" >> "${DEBUG_LOG:-$default_log}"
}

# 加载 .env 文件函数
load_env() {
  local env_files=(
    ".env"
    "../.env"
    "$HOME/.pr-sentinel.env"
  )
  
  log_debug "开始加载环境配置文件..."
  
  for env_file in "${env_files[@]}"; do
    log_debug "检查配置文件: $env_file"
    if [[ -f "$env_file" ]]; then
      log_info "找到配置文件: $env_file"
      echo -e "${GREEN}加载配置文件: $env_file${NC}"
      
      # 计数器
      local loaded_count=0
      
      # 导出文件中的环境变量，跳过注释和空行
      while IFS='=' read -r key value; do
        # 跳过注释和空行
        if [[ ! "$key" =~ ^# ]] && [[ -n "$key" ]]; then
          # 移除引号
          value="${value%\"}"
          value="${value#\"}"
          value="${value%\'}"
          value="${value#\'}"
          # 仅在变量未设置时导出
          if [[ -z "${!key:-}" ]]; then
            export "$key=$value"
            loaded_count=$((loaded_count + 1))
            log_debug "导出变量: $key=***"
          else
            log_debug "变量已存在，跳过: $key"
          fi
        fi
      done < <(grep -v '^#' "$env_file" | grep -v '^$')
      
      log_info "成功加载 $loaded_count 个环境变量"
      return 0
    else
      log_debug "文件不存在: $env_file"
    fi
  done
  
  log_error "未找到任何 .env 配置文件"
  echo -e "${YELLOW}未找到 .env 文件，使用系统环境变量${NC}"
  return 1
}

# 设置调试日志文件路径
export DEBUG_LOG="$SCRIPT_DIR/logs/debug/pr_review_$(date +%Y%m%d_%H%M%S).log"
mkdir -p "$(dirname "$DEBUG_LOG")"

log_info "========== 开始PR评审脚本 =========="
log_info "脚本版本: v3.0"
log_info "运行时间: $(date '+%Y-%m-%d %H:%M:%S')"

# 环境检查
log_debug "检查必要的命令..."
for cmd in claude curl grep sed; do
  if command -v $cmd >/dev/null 2>&1; then
    log_debug "✓ $cmd 命令存在: $(which $cmd)"
  else
    log_error "✗ $cmd 命令不存在"
    echo -e "${RED}❌ 缺少必要的命令: $cmd${NC}"
    exit 1
  fi
done

# 可选依赖 jq：用于稳定解析 JSON（缺失时走兼容解析）
if command -v jq >/dev/null 2>&1; then
  log_info "jq 已安装：将用于解析 JSON"
else
  log_info "未检测到 jq，将使用兼容的文本解析（建议安装 jq 以提升稳定性）"
fi

# 检查 Claude CLI
log_debug "检查 Claude CLI..."
if command -v claude >/dev/null 2>&1; then
  log_info "Claude CLI 路径: $(which claude)"
  # 尝试获取版本信息
  set +e
  CLAUDE_VERSION=$(claude --version 2>&1 | head -n 1)
  set -e
  log_info "Claude 版本: ${CLAUDE_VERSION:-未知}"
else
  log_error "Claude CLI 未安装或不在 PATH 中"
  echo -e "${RED}❌ 未找到 Claude CLI，请先安装：${NC}"
  echo -e "   npm install -g @anthropic-ai/claude-cli"
  exit 1
fi

# 加载环境配置
load_env || true

# MCP服务默认值（将在参数解析后可能被覆盖）
MCP_SERVICE="${MCP_SERVICE:-mcp-gitee}"

# 获取MCP命令前缀（用于Claude直接调用）
get_mcp_prefix() {
  if [[ "$MCP_SERVICE" == "mcp-gitee-ent" ]]; then
    echo "mcp__gitee-ent__"
  else
    echo "mcp__gitee__"
  fi
}

# 从环境变量读取默认配置
DEFAULT_REPO="${DEFAULT_REPO:-chazzorg/batch_ssh}"
DEFAULT_PR="1"

log_debug "默认仓库: $DEFAULT_REPO"
log_debug "默认PR: $DEFAULT_PR"

# 初始化变量
REPO="$DEFAULT_REPO"
PR_NUMBER="$DEFAULT_PR"
ENTERPRISE_ID=""
ENTERPRISE_PATH=""
PROJECT_ID=""

# 解析参数
log_debug "开始解析命令行参数..."
log_debug "参数数量: $#"
log_debug "参数列表: $@"

while [[ $# -gt 0 ]]; do
  log_debug "处理参数: $1"
  case "$1" in
    --repo)
      REPO="$2"
      log_info "设置仓库: $REPO"
      shift 2
      ;;
    --pr)
      PR_NUMBER="$2"
      log_info "设置PR编号: $PR_NUMBER"
      shift 2
      ;;
    --enterprise-id)
      ENTERPRISE_ID="$2"
      log_info "设置企业ID: $ENTERPRISE_ID"
      shift 2
      ;;
    --enterprise-path)
      ENTERPRISE_PATH="$2"
      log_info "设置企业路径: $ENTERPRISE_PATH"
      shift 2
      ;;
    --project-id)
      PROJECT_ID="$2"
      log_info "设置项目ID: $PROJECT_ID"
      shift 2
      ;;
    *)
      # 位置参数
      if [[ -z "$REPO" ]] || [[ "$REPO" == "$DEFAULT_REPO" ]]; then
        REPO="$1"
        log_info "通过位置参数设置仓库: $REPO"
      elif [[ -z "$PR_NUMBER" ]] || [[ "$PR_NUMBER" == "$DEFAULT_PR" ]]; then
        PR_NUMBER="$1"
        log_info "通过位置参数设置PR编号: $PR_NUMBER"
      fi
      shift
      ;;
  esac
done

log_info "最终参数: REPO=$REPO, PR_NUMBER=$PR_NUMBER"
if [[ -n "$ENTERPRISE_ID" ]]; then
  log_info "企业版参数: ENTERPRISE_ID=$ENTERPRISE_ID, ENTERPRISE_PATH=$ENTERPRISE_PATH, PROJECT_ID=$PROJECT_ID"
fi

# 检查MCP管理器是否存在
if [[ ! -f "$SCRIPT_DIR/mcp/mcp-manager.sh" ]]; then
  log_error "MCP管理器不存在: $SCRIPT_DIR/mcp/mcp-manager.sh"
  echo -e "${RED}❌ MCP配置系统未找到，请检查安装${NC}"
  exit 1
fi

log_info "加载MCP管理器"
source "$SCRIPT_DIR/mcp/mcp-manager.sh"

# 根据是否有企业ID自动选择MCP服务
if [[ -n "$ENTERPRISE_ID" ]]; then
  # 企业版模式
  log_info "检测到企业版参数，自动切换到企业版MCP服务"
  MCP_SERVICE="mcp-gitee-ent"
else
  # 使用配置的服务（默认或环境变量指定）
  log_info "使用配置的MCP服务: $MCP_SERVICE"
fi

# 加载MCP配置
if ! load_mcp_config "$MCP_SERVICE"; then
  log_error "无法加载MCP服务配置: $MCP_SERVICE"
  echo -e "${RED}❌ MCP服务配置加载失败${NC}"
  echo -e "${YELLOW}可用的MCP服务:${NC}"
  list_mcp_services
  exit 1
fi

# 配置环境变量
configure_mcp_env "$MCP_SERVICE"

# 重新设置MCP命令前缀和工具名
MCP_PREFIX=$(get_mcp_prefix)

# 获取命令映射（这些变量保留用于调试日志）
MCP_CMD_GET_PR=$(get_mapped_command "get_pull_detail" "$MCP_SERVICE")
MCP_CMD_GET_DIFF=$(get_mapped_command "get_diff_files" "$MCP_SERVICE")
MCP_CMD_COMMENT=$(get_mapped_command "comment_pull" "$MCP_SERVICE")
MCP_CMD_MERGE=$(get_mapped_command "merge_pull" "$MCP_SERVICE")
MCP_CMD_GET_USER=$(get_mapped_command "get_user_info" "$MCP_SERVICE")

# 设置实际的MCP工具命令名（给Claude使用）
if [[ "$MCP_SERVICE" == "mcp-gitee-ent" ]]; then
  MCP_TOOL_GET_PR="${MCP_PREFIX}get_enterprise_pull_detail"
  MCP_TOOL_GET_DIFF="${MCP_PREFIX}get_enterprise_pull_diff"
  MCP_TOOL_COMMENT="${MCP_PREFIX}comment_enterprise_pull"
  MCP_TOOL_MERGE="${MCP_PREFIX}merge_enterprise_pull"
  MCP_TOOL_GET_USER="${MCP_PREFIX}get_user_info"
else
  MCP_TOOL_GET_PR="${MCP_PREFIX}get_pull_detail"
  MCP_TOOL_GET_DIFF="${MCP_PREFIX}get_diff_files"
  MCP_TOOL_COMMENT="${MCP_PREFIX}comment_pull"
  MCP_TOOL_MERGE="${MCP_PREFIX}merge_pull"
  MCP_TOOL_GET_USER="${MCP_PREFIX}get_user_info"
fi

log_info "MCP命令映射配置完成 (服务: $MCP_SERVICE)"
log_debug "  Claude工具名（实际使用）:"
log_debug "    获取PR详情: $MCP_TOOL_GET_PR"
log_debug "    获取差异文件: $MCP_TOOL_GET_DIFF"
log_debug "    发布评论: $MCP_TOOL_COMMENT"
log_debug "    合并PR: $MCP_TOOL_MERGE"
log_debug "    获取用户信息: $MCP_TOOL_GET_USER"

# 环境变量（优先使用 .env 中的配置，其次是系统环境变量，最后是默认值）
export ENABLE_DINGTALK_NOTIFY="${ENABLE_DINGTALK_NOTIFY:-true}"
export DINGTALK_WEBHOOK_URL="${DINGTALK_WEBHOOK_URL:-}"
export AUTO_MERGE_IF_LOW_RISK="${AUTO_MERGE_IF_LOW_RISK:-true}"
export MERGE_METHOD="${MERGE_METHOD:-squash}"
export REQUIRE_LABEL_FOR_MERGE="${REQUIRE_LABEL_FOR_MERGE:-}"
export BLOCK_PATH_PATTERNS="${BLOCK_PATH_PATTERNS:-^infra/|^deploy/|^scripts/|^security/}"
export MAX_LINES_FOR_AUTO_MERGE="${MAX_LINES_FOR_AUTO_MERGE:-800}"
# 新变量名，更准确地描述功能
export ENABLE_REVIEW_STANDARDS="${ENABLE_REVIEW_STANDARDS:-true}"
# 保持向后兼容，如果旧变量存在则使用旧变量
export ENABLE_LANGUAGE_SPECIFIC_REVIEW="${ENABLE_LANGUAGE_SPECIFIC_REVIEW:-$ENABLE_REVIEW_STANDARDS}"
export REVIEW_STANDARDS_DIR="${REVIEW_STANDARDS_DIR:-./review}"
export ENABLE_SCORE_RECORDING="${ENABLE_SCORE_RECORDING:-true}"
export SCORE_DIR="${SCORE_DIR:-./score}"

# 检查钉钉通知配置
if [[ "$ENABLE_DINGTALK_NOTIFY" == "true" ]] && [[ -z "$DINGTALK_WEBHOOK_URL" ]]; then
  echo -e "${RED}❌ 错误：启用了钉钉通知但未设置 DINGTALK_WEBHOOK_URL${NC}"
  exit 1
fi

echo -e "${CYAN}╔══════════════════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║          🤖 Gitee PR 中文评审 + 钉钉通知                  ║${NC}"
echo -e "${CYAN}╚══════════════════════════════════════════════════════════╝${NC}"
echo

echo -e "${BLUE}📊 目标${NC}"
echo -e "   仓库: ${GREEN}${REPO}${NC}"
echo -e "   PR:   ${GREEN}#${PR_NUMBER}${NC}"
echo

# 获取PR详细信息（标题和提交人）
echo -e "${YELLOW}获取PR详细信息...${NC}"
log_info "准备进行PR评审: ${REPO}#${PR_NUMBER}"

# 这些信息将从主评审结果中解析
PR_TITLE="待解析"
PR_AUTHOR="待解析"
FILE_COUNT="0"
LINE_CHANGES="待解析"

echo -e "${GREEN}开始评审流程...${NC}"
echo

# 加载所有评审标准
REVIEW_STANDARDS=""

if [[ "$ENABLE_LANGUAGE_SPECIFIC_REVIEW" == "true" ]]; then
  echo -e "${YELLOW}加载评审标准...${NC}"
  
  # 检查评审标准目录是否存在
  if [[ -d "${REVIEW_STANDARDS_DIR}" ]]; then
    # 统计标准文件数量
    STANDARDS_COUNT=$(find "${REVIEW_STANDARDS_DIR}" -name "*.md" -type f 2>/dev/null | wc -l | tr -d ' ')
    
    if [[ "$STANDARDS_COUNT" -gt 0 ]]; then
      echo -e "${GREEN}找到 ${STANDARDS_COUNT} 个评审标准文件${NC}"
      
      # 合并所有评审标准文件
      REVIEW_STANDARDS=""
      for standard_file in "${REVIEW_STANDARDS_DIR}"/*.md; do
        if [[ -f "$standard_file" ]]; then
          filename=$(basename "$standard_file")
          echo -e "   加载: ${CYAN}${filename}${NC}"
          
          # 添加文件标题分隔
          REVIEW_STANDARDS="${REVIEW_STANDARDS}

========== ${filename} ==========
"
          # 追加文件内容
          REVIEW_STANDARDS="${REVIEW_STANDARDS}$(cat "$standard_file")"
        fi
      done
      
      echo -e "${GREEN}✅ 已加载所有评审标准${NC}"
    else
      echo -e "${YELLOW}⚠️ 评审标准目录为空，将使用基础评审${NC}"
    fi
  else
    echo -e "${YELLOW}⚠️ 评审标准目录不存在，将使用基础评审${NC}"
  fi
fi

# 步骤1：执行中文评审
echo -e "${YELLOW}步骤 1: 执行中文代码评审...${NC}"

# 为 JSON 安全转义敏感路径正则
SAFE_PATTERNS="${BLOCK_PATH_PATTERNS}"
SAFE_PATTERNS="${SAFE_PATTERNS//\\/\\\\}"
SAFE_PATTERNS="${SAFE_PATTERNS//\"/\\\"}"

# 创建综合评审指令，使用JSON+Markdown双通道输出
if [[ -n "$REVIEW_STANDARDS" ]]; then
  # 根据是否为企业版构建不同的命令参数说明
  if [[ -n "$ENTERPRISE_ID" ]]; then
    # 企业版：使用enterprise_id和project_id
    REVIEW_CMD="请使用${MCP_TOOL_GET_PR}工具获取企业版PR详情，参数：
- enterprise_id: ${ENTERPRISE_ID}
- project_id: ${PROJECT_ID}
- pr_number: ${PR_NUMBER}

使用${MCP_TOOL_GET_DIFF}工具获取代码变更，参数：
- enterprise_id: ${ENTERPRISE_ID}
- project_id: ${PROJECT_ID}
- pr_number: ${PR_NUMBER}"
  else
    # 个人版：使用owner和repo
    OWNER="${REPO%%/*}"
    REPO_NAME="${REPO##*/}"
    REVIEW_CMD="请使用${MCP_TOOL_GET_PR}工具获取PR详情，参数：
- owner: ${OWNER}
- repo: ${REPO_NAME}
- number: ${PR_NUMBER}

使用${MCP_TOOL_GET_DIFF}工具获取代码变更，参数：
- owner: ${OWNER}
- repo: ${REPO_NAME}
- number: ${PR_NUMBER}"
  fi
  
  REVIEW_CMD="${REVIEW_CMD}

请按照以下格式输出评审结果：

【第一部分：JSON数据】
请先输出以下格式的JSON（必须是严格的JSON格式，不要有任何额外文字）：
\`\`\`json
{
  \"summary\": {
    \"title\": \"PR标题\",
    \"author\": \"提交人\",
    \"target_branch\": \"目标分支\",
    \"files\": 文件数量,
    \"lines_changed\": 改动行数
  },
  \"risk\": {
    \"level\": \"high|medium|low|unknown\",
    \"reasons\": [\"风险原因1\", \"风险原因2\"]
  },
  \"auto_merge\": {
    \"is_draft\": false,
    \"has_conflicts\": false,
    \"lines_changed\": 改动行数,
    \"has_sensitive_paths\": false,
    \"sensitive_files\": [],
    \"sensitive_patterns\": \"${SAFE_PATTERNS}\",
    \"ci_status\": \"passed|failed|skipped|unknown\",
    \"recommendation\": \"allow|deny|unknown\"
  },
  \"violations\": [
    {\"id\": \"STD-001\", \"evidence\": \"具体违规代码或描述\"}
  ]
}
\`\`\`

【第二部分：Markdown评审报告】
然后，按照以下加载的评审标准进行全面分析，用中文输出详细的Markdown格式评审报告：

${REVIEW_STANDARDS}

Markdown报告应包含：
1. PR概况总结
2. 发现的具体问题（按严重程度排序）
3. 改进建议
4. 风险等级评估（🔴高风险 🟡中等风险 🟢低风险）
5. 推荐的下一步操作

请确保JSON部分严格遵循格式，Markdown部分详细易读。"
else
  # 根据是否为企业版构建不同的命令参数说明
  if [[ -n "$ENTERPRISE_ID" ]]; then
    # 企业版：使用enterprise_id和project_id
    REVIEW_CMD="请使用${MCP_TOOL_GET_PR}工具获取企业版PR详情，参数：
- enterprise_id: ${ENTERPRISE_ID}
- project_id: ${PROJECT_ID}
- pr_number: ${PR_NUMBER}

使用${MCP_TOOL_GET_DIFF}工具获取代码变更，参数：
- enterprise_id: ${ENTERPRISE_ID}
- project_id: ${PROJECT_ID}
- pr_number: ${PR_NUMBER}"
  else
    # 个人版：使用owner和repo
    OWNER="${REPO%%/*}"
    REPO_NAME="${REPO##*/}"
    REVIEW_CMD="请使用${MCP_TOOL_GET_PR}工具获取PR详情，参数：
- owner: ${OWNER}
- repo: ${REPO_NAME}
- number: ${PR_NUMBER}

使用${MCP_TOOL_GET_DIFF}工具获取代码变更，参数：
- owner: ${OWNER}
- repo: ${REPO_NAME}
- number: ${PR_NUMBER}"
  fi
  
  REVIEW_CMD="${REVIEW_CMD}

请执行完整的代码评审，并按照以下格式输出所有结果：

【第一部分：JSON数据】
请先输出以下格式的JSON（必须是严格的JSON格式，不要有任何额外文字）：
\`\`\`json
{
  \"summary\": {
    \"title\": \"PR标题\",
    \"author\": \"提交人\",
    \"target_branch\": \"目标分支\",
    \"files\": 文件数量,
    \"lines_changed\": 改动行数
  },
  \"risk_assessment\": {
    \"level\": \"high|medium|low\",
    \"score\": 1-100的数字,
    \"reasons\": [\"风险原因1\", \"风险原因2\"]
  },
  \"auto_merge_decision\": {
    \"can_merge\": true|false,
    \"is_draft\": false,
    \"has_conflicts\": false,
    \"lines_changed\": 改动行数,
    \"has_sensitive_paths\": false,
    \"sensitive_files\": [],
    \"sensitive_patterns\": \"${SAFE_PATTERNS}\",
    \"ci_status\": \"passed|failed|skipped|unknown\",
    \"blockers\": [\"阻塞原因1\", \"阻塞原因2\"],
    \"recommendation\": \"allow|deny\"
  },
  \"issues_found\": [
    {
      \"type\": \"security|performance|quality|logic|style\",
      \"severity\": \"critical|major|minor|info\",
      \"file\": \"文件路径\",
      \"line\": 行号或null,
      \"description\": \"问题描述\",
      \"suggestion\": \"修复建议\"
    }
  ],
  \"improvements\": [
    {
      \"category\": \"架构|性能|安全|可维护性|测试\",
      \"suggestion\": \"改进建议描述\",
      \"priority\": \"high|medium|low\"
    }
  ],
  \"overall_evaluation\": {
    \"quality_score\": 1-100的数字,
    \"test_coverage\": \"充分|一般|不足|无\",
    \"code_style\": \"优秀|良好|一般|需改进\",
    \"summary\": \"总体评价文字描述\"
  },
  \"merge_execution\": {
    \"should_execute\": true|false,
    \"merge_method\": \"${MERGE_METHOD}\",
    \"expected_result\": \"success|failure\",
    \"failure_reasons\": []
  },
  \"scoring\": {
    \"enabled\": ${ENABLE_SCORE_RECORDING:-false},
    \"base_score\": 100,
    \"deductions\": [
      {\"reason\": \"扣分原因\", \"points\": 扣分数}
    ],
    \"bonuses\": [
      {\"reason\": \"加分原因\", \"points\": 加分数}
    ],
    \"final_score\": 最终得分
  }
}
\`\`\`

【第二部分：Markdown评审报告】
然后，用中文输出详细的Markdown格式评审报告，包含：

## 📊 PR概况
- 标题、作者、目标分支等基本信息

## 🎯 风险评估
- 风险等级（使用🔴高风险 🟡中等风险 🟢低风险）
- 风险评分和具体原因

## 🔍 发现的问题
- 按严重程度排序的具体问题列表
- 每个问题包含类型、位置、描述和修复建议

## 💡 改进建议
- 分类整理的改进建议
- 标注优先级

## ✅ 自动合并决策
- 是否可以自动合并及原因
- 如有阻塞因素，详细说明

## 📈 总体评价
- 代码质量评分
- 测试覆盖情况
- 代码风格评价
- 综合评价总结

## 🎬 推荐的下一步操作
- 基于评审结果的具体行动建议

请确保JSON部分严格遵循格式，包含所有必需字段。"
fi

# 确保评审日志目录存在
mkdir -p "$SCRIPT_DIR/logs/reviews"

# 生成带时间戳的评审文件名
REVIEW_LOG="$SCRIPT_DIR/logs/reviews/review-${REPO//\//-}-pr${PR_NUMBER}-$(date +%Y%m%d-%H%M%S).log"

log_info "开始执行代码评审..."
log_debug "评审日志将保存到: $REVIEW_LOG"

# 执行评审并保存输出
set +e  # 临时禁用错误退出

# MCP工具权限预检查和处理
check_mcp_permissions() {
  log_debug "检查MCP工具权限状态"
  
  # 测试MCP服务连接，设置较短的超时时间
  local test_output
  local test_exit_code
  
  # 使用更简单的测试命令，减少网络依赖
  test_output=$(echo "test" | timeout 30s claude --permission-mode bypassPermissions 2>&1 || echo "")
  test_exit_code=$?
  
  log_debug "权限测试输出: $test_output"
  log_debug "权限测试退出码: $test_exit_code"
  
  # 检查各种失败情况
  if [[ $test_exit_code -eq 124 ]]; then
    log_error "MCP权限检查超时"
    return 4
  elif echo "$test_output" | grep -q "You need to grant permission"; then
    log_error "检测到MCP权限未授予，尝试自动处理"
    return 1
  elif echo "$test_output" | grep -q "Raw mode is not supported"; then
    log_error "检测到终端交互模式问题"
    return 2
  elif [[ -z "$test_output" ]] && [[ $test_exit_code -eq 0 ]]; then
    log_error "MCP连接测试无输出但退出码为0，可能存在问题"
    return 3
  elif [[ $test_exit_code -ne 0 ]]; then
    log_error "Claude CLI执行失败，退出码: $test_exit_code"
    return 5
  else
    log_debug "MCP权限检查通过"
    return 0
  fi
}

# 执行MCP权限检查
if ! check_mcp_permissions; then
  mcp_check_result=$?
  case $mcp_check_result in
    1)
      log_error "MCP权限问题，将在评审命令中处理"
      ;;
    2)
      log_error "终端交互模式问题，将使用文件输入方式"
      ;;
    3)
      log_error "MCP连接异常，继续尝试评审"
      ;;
    4)
      log_error "MCP权限检查超时，可能存在网络问题"
      ;;
    5)
      log_error "Claude CLI执行异常，继续尝试评审"
      ;;
  esac
fi

# 增加超时时间到 600 秒（10 分钟），因为使用MCP工具的代码评审需要更长时间
log_debug "开始执行 Claude 评审，超时设置为 600 秒"

# 创建临时文件来处理Claude CLI输入输出
TEMP_INPUT=$(mktemp)
TEMP_OUTPUT=$(mktemp)
TEMP_ERROR=$(mktemp)

# 将评审命令写入临时文件
echo "$REVIEW_CMD" > "$TEMP_INPUT"

# 记录Claude CLI执行详情
log_debug "开始执行Claude CLI命令"
log_debug "输入文件: $TEMP_INPUT ($(wc -c < "$TEMP_INPUT") 字节)"
log_debug "命令: claude -p \"评审 ${REPO} PR #${PR_NUMBER}\" --permission-mode default"

# 预先配置Claude CLI来自动接受权限
configure_claude_permissions() {
  local claude_config="/home/ubuntu/.claude.json"
  if [[ -f "$claude_config" ]]; then
    log_debug "配置Claude CLI自动接受bypassPermissions"
    # 创建备份
    cp "$claude_config" "${claude_config}.bak" 2>/dev/null || true
    
    # 使用jq添加bypassPermissions接受标志（如果jq可用）
    if command -v jq &> /dev/null; then
      jq '.cachedStatsigGates.bypass_permissions_accepted = true' "$claude_config" > "${claude_config}.tmp" && 
      mv "${claude_config}.tmp" "$claude_config" 2>/dev/null || true
    fi
  fi
}

# 配置权限
configure_claude_permissions

# 使用bypassPermissions模式，但设置非交互环境变量
export CI=true
export TERM=dumb
export DEBIAN_FRONTEND=noninteractive

# 执行Claude CLI (改为同步执行，避免竞态条件)
# 增加重试机制处理间歇性失败
log_debug "开始同步执行Claude CLI命令，支持重试"
REVIEW_EXIT_CODE=0
RETRY_COUNT=0
MAX_RETRIES=3

while [[ $RETRY_COUNT -lt $MAX_RETRIES ]]; do
  log_debug "第 $((RETRY_COUNT + 1)) 次尝试执行Claude CLI"
  
  timeout 600s bash -c "
  export CI=true TERM=dumb DEBIAN_FRONTEND=noninteractive
  cat '$TEMP_INPUT' | claude -p '评审 ${REPO} PR #${PR_NUMBER}' --permission-mode bypassPermissions
  " > "$TEMP_OUTPUT" 2> "$TEMP_ERROR"
  REVIEW_EXIT_CODE=$?
  
  # 读取输出
  REVIEW_OUTPUT=$(cat "$TEMP_OUTPUT" 2>/dev/null || echo "")
  REVIEW_ERROR=$(cat "$TEMP_ERROR" 2>/dev/null || echo "")
  
  # 如果有有效输出且退出码为0，则成功
  if [[ -n "$REVIEW_OUTPUT" ]] && [[ $REVIEW_EXIT_CODE -eq 0 ]]; then
    log_debug "第 $((RETRY_COUNT + 1)) 次尝试成功"
    break
  fi
  
  # 如果失败且还有重试次数
  if [[ $RETRY_COUNT -lt $((MAX_RETRIES - 1)) ]]; then
    log_error "第 $((RETRY_COUNT + 1)) 次尝试失败，输出长度: ${#REVIEW_OUTPUT}，退出码: $REVIEW_EXIT_CODE"
    log_error "等待3秒后重试..."
    sleep 3
  fi
  
  RETRY_COUNT=$((RETRY_COUNT + 1))
done

log_debug "Claude CLI执行完成，总尝试次数: $RETRY_COUNT"

# 输出和错误信息已在循环中读取，无需重复读取

# 记录详细的执行结果
log_debug "Claude CLI执行完成"
log_debug "退出代码: $REVIEW_EXIT_CODE"
log_debug "标准输出长度: ${#REVIEW_OUTPUT} 字符"
log_debug "错误输出长度: ${#REVIEW_ERROR} 字符"

# 如果有错误输出，记录到日志
if [[ -n "$REVIEW_ERROR" ]]; then
  log_error "Claude CLI stderr输出:"
  log_error "$REVIEW_ERROR"
fi

# 清理临时文件
rm -f "$TEMP_INPUT" "$TEMP_OUTPUT" "$TEMP_ERROR"
set -e  # 恢复错误退出

# 记录详细的调试信息
log_debug "Claude 评审命令执行完成"
log_debug "退出代码: $REVIEW_EXIT_CODE"
log_debug "输出长度: ${#REVIEW_OUTPUT} 字符"

# 如果超时，记录特定的错误信息
if [[ $REVIEW_EXIT_CODE -eq 124 ]]; then
  log_error "Claude 评审执行超时（600秒）"
  echo -e "${RED}❌ Claude 评审超时，可能是网络问题或 PR 过于复杂${NC}"
fi

# 分析失败原因并记录详细信息
analyze_review_failure() {
  local output="$1"
  local exit_code="$2"
  
  log_error "=== 评审失败分析 ==="
  log_error "退出代码: $exit_code"
  log_error "输出长度: ${#output}"
  log_error "原始输出: '$output'"
  
  # 分析具体失败原因
  if [[ $exit_code -eq 124 ]]; then
    log_error "失败原因: 执行超时（600秒）"
    echo -e "${RED}❌ 评审失败：执行超时，可能是网络问题或PR过于复杂${NC}"
  elif [[ -z "$output" ]]; then
    log_error "失败原因: 输出为空"
    # 检查常见的空输出原因
    if echo "$output" | grep -q "permission"; then
      log_error "可能原因: MCP工具权限未授予"
      echo -e "${RED}❌ 评审失败：MCP工具权限问题${NC}"
    elif echo "$output" | grep -q "Raw mode"; then
      log_error "可能原因: 终端交互模式问题"
      echo -e "${RED}❌ 评审失败：终端交互模式不支持${NC}"
    elif echo "$output" | grep -q "network\|timeout\|connection"; then
      log_error "可能原因: 网络连接问题"
      echo -e "${RED}❌ 评审失败：网络连接问题${NC}"
    else
      log_error "可能原因: Claude CLI执行异常"
      echo -e "${RED}❌ 评审失败：Claude CLI执行异常${NC}"
    fi
  elif echo "$output" | grep -q "Error\|error\|ERROR"; then
    log_error "失败原因: 执行过程中出现错误"
    # 提取错误信息
    local error_lines=$(echo "$output" | grep -i "error" | head -3)
    log_error "错误详情: $error_lines"
    echo -e "${RED}❌ 评审失败：$error_lines${NC}"
  else
    log_error "失败原因: 未知错误"
    echo -e "${RED}❌ 评审失败：未知错误${NC}"
  fi
  
  # 记录调试建议
  log_error "=== 调试建议 ==="
  log_error "1. 检查Claude CLI权限：echo 'test' | claude --permission-mode bypassPermissions"
  log_error "2. 测试MCP服务连接：echo '${MCP_CMD_GET_USER}' | claude"
  log_error "3. 检查MCP服务配置：./mcp/mcp-manager.sh info $MCP_SERVICE"
  log_error "3. 查看完整日志：tail -f logs/debug/pr_review_debug_*.log"
  log_error "4. 手动测试：./start_review.sh --repo $REPO --pr $PR_NUMBER"
}

# 检查输出是否为空或包含错误
# 即使退出码为0，如果输出为空也应该视为失败
if [[ -z "$REVIEW_OUTPUT" ]] || [[ $REVIEW_EXIT_CODE -ne 0 ]]; then
  analyze_review_failure "$REVIEW_OUTPUT" "$REVIEW_EXIT_CODE"
  
  # 设置失败标志
  REVIEW_FAILED=true
  REVIEW_OUTPUT="评审执行失败，详细信息请查看日志"
  
  # 特别处理：退出码为0但输出为空的情况
  if [[ $REVIEW_EXIT_CODE -eq 0 ]] && [[ -z "$REVIEW_OUTPUT" ]]; then
    log_error "Claude CLI返回成功但输出为空，可能是网络问题或API响应异常"
  fi
else
  REVIEW_FAILED=false
  log_info "Claude 评审执行成功，输出长度: ${#REVIEW_OUTPUT} 字符"
fi

echo "$REVIEW_OUTPUT"
echo "$REVIEW_OUTPUT" > "$REVIEW_LOG"

log_debug "评审命令退出码: $REVIEW_EXIT_CODE"

if [[ $REVIEW_EXIT_CODE -ne 0 ]] && [[ $REVIEW_EXIT_CODE -ne 124 ]]; then
  # 124 是 timeout 的退出码，已经在上面处理了
  log_error "评审命令执行失败，退出码: $REVIEW_EXIT_CODE"
  echo -e "${RED}❌ 评审执行失败（退出码: $REVIEW_EXIT_CODE）${NC}"
  echo -e "   查看日志: $REVIEW_LOG"
  echo -e "   调试日志: $DEBUG_LOG"
  
  # 如果有部分输出，尝试使用；否则使用默认内容
  if [[ -z "$REVIEW_OUTPUT" ]]; then
    log_error "无任何输出，将使用默认评审内容"
  else
    log_info "虽然命令失败，但有部分输出可用，长度: ${#REVIEW_OUTPUT} 字符"
  fi
elif [[ $REVIEW_EXIT_CODE -eq 0 ]]; then
  log_info "评审命令执行成功"
fi


# 步骤2：解析评审结果
echo -e "\n${YELLOW}步骤 2: 解析评审结果...${NC}"

# 如果评审失败，设置默认值并跳过详细解析
if [[ "$REVIEW_FAILED" == "true" ]]; then
  RISK_LEVEL="未知"
  RISK_EMOJI="❌"
  CAN_AUTO_MERGE=false
  MERGE_RESULT="❌ 评审失败"
  REVIEW_SCORE=0
  QUALITY_SCORE=0
  CRITICAL_ISSUES=0
  MAJOR_ISSUES=0
  TEST_COVERAGE=""
  CODE_STYLE=""
  log_error "评审失败，设置默认值并跳过详细解析"
else
  # 初始化默认值与数组，避免 set -u 未绑定错误
  declare -a MERGE_BLOCKERS=()
  CAN_AUTO_MERGE=${CAN_AUTO_MERGE:-false}
  SHOULD_EXECUTE_MERGE=${SHOULD_EXECUTE_MERGE:-false}
  CI_STATUS=${CI_STATUS:-unknown}

  # 首先尝试从JSON中提取数据
JSON_DATA=""
REVIEW_JSON_FILE="/tmp/review_json_$$_$(date +%s).json"

# 提取JSON部分（在```json和```之间）
if grep -q '```json' "$REVIEW_LOG"; then
  # 提取JSON块
  sed -n '/```json/,/```/{//!p}' "$REVIEW_LOG" > "$REVIEW_JSON_FILE"
  
fi

# 若未找到 fenced JSON，回退尝试抓取首个大括号对象
if [[ ! -s "$REVIEW_JSON_FILE" ]]; then
  awk 'BEGIN{p=0;d=0}
       /{/ && p==0 {p=1}
       p==1 {print}
       /}/ && p==1 {exit}
  ' "$REVIEW_LOG" > "$REVIEW_JSON_FILE" || true
fi

  if [[ -s "$REVIEW_JSON_FILE" ]]; then
    log_info "成功提取JSON数据，文件: $REVIEW_JSON_FILE"
    JSON_DATA=$(cat "$REVIEW_JSON_FILE")
    
    # 使用jq解析JSON（如果可用）
    if command -v jq &> /dev/null; then
      log_info "使用jq解析JSON数据"
      
      # 提取summary信息
      PR_TITLE=$(echo "$JSON_DATA" | jq -r '.summary.title // "未知标题"' 2>/dev/null || echo "未知标题")
      PR_AUTHOR=$(echo "$JSON_DATA" | jq -r '.summary.author // "unknown"' 2>/dev/null || echo "unknown")
      FILE_COUNT=$(echo "$JSON_DATA" | jq -r '.summary.files // 0' 2>/dev/null || echo "0")
      LINE_CHANGES=$(echo "$JSON_DATA" | jq -r '.summary.lines_changed // 0' 2>/dev/null || echo "0")
      
      # 兼容两套 schema：risk_assessment/auto_merge_decision 与 risk/auto_merge
      RISK_LEVEL_JSON=$(echo "$JSON_DATA" | jq -r '.risk_assessment.level // .risk.level // "unknown"' 2>/dev/null || echo "unknown")
      RISK_SCORE=$(echo "$JSON_DATA" | jq -r '.risk_assessment.score // .overall_evaluation.quality_score // 50' 2>/dev/null || echo "50")
      case "$RISK_LEVEL_JSON" in
        "high")
          RISK_LEVEL="高风险"
          RISK_EMOJI="🔴"
          ;;
        "medium")
          RISK_LEVEL="中等风险"
          RISK_EMOJI="🟡"
          ;;
        "low")
          RISK_LEVEL="低风险"
          RISK_EMOJI="🟢"
          ;;
        *)
          RISK_LEVEL="未知"
          RISK_EMOJI="❓"
          ;;
      esac
      
      # 提取自动合并决策（两套 schema 兼容）
      CAN_AUTO_MERGE=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.can_merge // (.auto_merge.recommendation=="allow") // false' 2>/dev/null || echo "false")
      IS_DRAFT=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.is_draft // .auto_merge.is_draft // false' 2>/dev/null || echo "false")
      HAS_CONFLICTS=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.has_conflicts // .auto_merge.has_conflicts // false' 2>/dev/null || echo "false")
      HAS_SENSITIVE=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.has_sensitive_paths // .auto_merge.has_sensitive_paths // false' 2>/dev/null || echo "false")
      CI_STATUS=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.ci_status // .auto_merge.ci_status // "unknown"' 2>/dev/null || echo "unknown")
      MERGE_RECOMMENDATION=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.recommendation // .auto_merge.recommendation // "unknown"' 2>/dev/null || echo "unknown")
      
      # 提取阻塞原因（两套 schema 兼容）
      MERGE_BLOCKERS_JSON=$(echo "$JSON_DATA" | jq -r '.auto_merge_decision.blockers[]? // .auto_merge.blockers[]? // empty' 2>/dev/null)
      if [[ -n "$MERGE_BLOCKERS_JSON" ]]; then
        while IFS= read -r line; do
          [[ -n "$line" ]] && MERGE_BLOCKERS+=("$line")
        done <<< "$MERGE_BLOCKERS_JSON"
      fi
      
      # 提取问题列表
      CRITICAL_ISSUES=$(echo "$JSON_DATA" | jq -r '[.issues_found[] | select(.severity == "critical")] | length' 2>/dev/null || echo "0")
      MAJOR_ISSUES=$(echo "$JSON_DATA" | jq -r '[.issues_found[] | select(.severity == "major")] | length' 2>/dev/null || echo "0")
      
      # 提取总体评价
      QUALITY_SCORE=$(echo "$JSON_DATA" | jq -r '.overall_evaluation.quality_score // 70' 2>/dev/null || echo "70")
      TEST_COVERAGE=$(echo "$JSON_DATA" | jq -r '.overall_evaluation.test_coverage // "未知"' 2>/dev/null || echo "未知")
      CODE_STYLE=$(echo "$JSON_DATA" | jq -r '.overall_evaluation.code_style // "一般"' 2>/dev/null || echo "一般")
      
      # 提取评分信息
      if [[ "$ENABLE_SCORE_RECORDING" == "true" ]]; then
        REVIEW_SCORE=$(echo "$JSON_DATA" | jq -r '.scoring.final_score // 70' 2>/dev/null || echo "70")
      else
        REVIEW_SCORE=$QUALITY_SCORE
      fi
      
      # 提取合并执行建议
      SHOULD_EXECUTE_MERGE=$(echo "$JSON_DATA" | jq -r '.merge_execution.should_execute // false' 2>/dev/null || echo "false")
      
      echo -e "${GREEN}✅ 成功从JSON解析数据${NC}"
    else
      log_info "jq不可用，使用兼容的文本解析JSON（精度较低）"
      # 使用 sed/grep -E 作为备选方案（BSD 兼容）
      PR_TITLE=$(printf '%s' "$JSON_DATA" | sed -n 's/.*"title"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
      PR_AUTHOR=$(printf '%s' "$JSON_DATA" | sed -n 's/.*"author"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1)
      LINE_CHANGES=$(printf '%s' "$JSON_DATA" | sed -n 's/.*"lines_changed"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -n1)
      
      # 解析风险等级（尽力而为）
      if printf '%s' "$JSON_DATA" | grep -E '"level"[[:space:]]*:[[:space:]]*"high"' >/dev/null; then
        RISK_LEVEL="高风险"
        RISK_EMOJI="🔴"
      elif printf '%s' "$JSON_DATA" | grep -E '"level"[[:space:]]*:[[:space:]]*"medium"' >/dev/null; then
        RISK_LEVEL="中等风险"
        RISK_EMOJI="🟡"
      elif printf '%s' "$JSON_DATA" | grep -E '"level"[[:space:]]*:[[:space:]]*"low"' >/dev/null; then
        RISK_LEVEL="低风险"
        RISK_EMOJI="🟢"
      else
        RISK_LEVEL="未知"
        RISK_EMOJI="❓"
      fi
      
      # 提取风险分数/质量分数（尽力而为）
      RISK_SCORE=$(printf '%s' "$JSON_DATA" | sed -n 's/.*"score"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -n1)
      : "${RISK_SCORE:=50}"
      
      # 提取自动合并决策
      if printf '%s' "$JSON_DATA" | grep -E '"can_merge"[[:space:]]*:[[:space:]]*true' >/dev/null; then
        CAN_AUTO_MERGE=true
      elif printf '%s' "$JSON_DATA" | grep -E '"recommendation"[[:space:]]*:[[:space:]]*"allow"' >/dev/null; then
        CAN_AUTO_MERGE=true
      else
        CAN_AUTO_MERGE=false
      fi
      
      # 提取质量分数
      QUALITY_SCORE=$(printf '%s' "$JSON_DATA" | sed -n 's/.*"quality_score"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -n1)
      : "${QUALITY_SCORE:=70}"
      REVIEW_SCORE=$(printf '%s' "$JSON_DATA" | sed -n 's/.*"final_score"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -n1)
      : "${REVIEW_SCORE:=$QUALITY_SCORE}"
    fi
  else
    log_error "无法提取JSON数据"
  fi
  
  # 如果没有JSON数据，使用传统解析方式作为后备
  if [[ -z "$RISK_LEVEL" ]]; then
    log_info "使用传统解析方式"
    RISK_LEVEL="未知"
    RISK_EMOJI="❓"
    
    # 更全面的风险等级识别（支持中英文）
    if grep -Ei "高风险|high[[:space:]]*risk|🔴.*高|风险等级.*高|严重.*问题|必须.*修复|blocker|risk:[[:space:]]*high" "$REVIEW_LOG"; then
      RISK_LEVEL="高风险"
      RISK_EMOJI="🔴"
    elif grep -Ei "中等风险|medium[[:space:]]*risk|🟡.*中|风险等级.*中|建议.*修复|major.*问题|risk:[[:space:]]*medium" "$REVIEW_LOG"; then
      RISK_LEVEL="中等风险"
      RISK_EMOJI="🟡"
    elif grep -Ei "低风险|low[[:space:]]*risk|🟢.*低|风险等级.*低|可以.*合并|安全|minor|risk:[[:space:]]*low" "$REVIEW_LOG"; then
      RISK_LEVEL="低风险"
      RISK_EMOJI="🟢"
    else
      # 如果无法识别，尝试从输出中提取更多线索
      if grep -qi "错误\|error\|bug\|issue" "$REVIEW_LOG"; then
        RISK_LEVEL="中等风险"  # 有问题默认中等
        RISK_EMOJI="🟡"
      elif grep -qi "完美\|很好\|没有.*问题\|looks good" "$REVIEW_LOG"; then
        RISK_LEVEL="低风险"  # 没问题默认低
        RISK_EMOJI="🟢"
      else
        RISK_LEVEL="中等风险"  # 无法判断默认中等
        RISK_EMOJI="🟡"
      fi
    fi
  fi
fi  # 关闭 REVIEW_FAILED 检查的 else 块

# 设置默认值
PR_TITLE="${PR_TITLE:-未知标题}"
PR_AUTHOR="${PR_AUTHOR:-unknown}"
FILE_COUNT="${FILE_COUNT:-0}"
LINE_CHANGES="${LINE_CHANGES:-0}"

echo -e "${GREEN}✅ 评审完成${NC}"
echo -e "   风险等级：${RISK_EMOJI} ${RISK_LEVEL}"
echo -e "   PR标题: ${PR_TITLE}"
echo -e "   提交人: ${PR_AUTHOR}"
echo -e "   改动行数: ${LINE_CHANGES}"


# 步骤3：低风险自动合并
echo -e "\n${YELLOW}步骤 3: 检查自动合并条件...${NC}"

# 初始化合并变量（如果还没有初始化）
MERGE_EXECUTED=${MERGE_EXECUTED:-false}
MERGE_RESULT=${MERGE_RESULT:-"未执行"}
# 确保数组存在（避免unbound variable错误）
if [[ -z "${MERGE_BLOCKERS+x}" ]]; then
  declare -a MERGE_BLOCKERS=()
fi

# 如果评审失败，跳过自动合并
if [[ "$REVIEW_FAILED" == "true" ]]; then
  echo -e "${RED}❌ 评审失败，跳过自动合并${NC}"
  MERGE_RESULT="❌ 评审失败"
  CAN_AUTO_MERGE=false
elif [[ "$RISK_LEVEL" == "低风险" ]] && [[ "$AUTO_MERGE_IF_LOW_RISK" == "true" ]]; then
  echo -e "${GREEN}✅ 检测到低风险PR，检查自动合并条件...${NC}"
  
  # 使用从JSON提取的合并决策（AI已经评估了所有条件）
  if [[ "$CAN_AUTO_MERGE" == "true" ]] || [[ "$SHOULD_EXECUTE_MERGE" == "true" ]]; then
    echo -e "${BLUE}基于AI评审建议，可以执行自动合并${NC}"
    
    # 显示AI评估的详细信息
    echo -e "\n${BLUE}自动合并条件检查（由AI完成）：${NC}"
    
    if [[ "$IS_DRAFT" == "true" ]]; then
      echo -e "   ${RED}❌ PR是草稿状态${NC}"
    else
      echo -e "   ${GREEN}✅ PR非草稿状态${NC}"
    fi
    
    if [[ "$HAS_CONFLICTS" == "true" ]]; then
      echo -e "   ${RED}❌ 存在合并冲突${NC}"
    else
      echo -e "   ${GREEN}✅ 无合并冲突${NC}"
    fi
    
    echo -e "   ${GREEN}✅ 改动行数：${LINE_CHANGES} 行${NC}"
    
    if [[ "$HAS_SENSITIVE" == "true" ]]; then
      echo -e "   ${RED}❌ 包含敏感路径变更${NC}"
    else
      echo -e "   ${GREEN}✅ 不包含敏感路径${NC}"
    fi
    
    CI_STATUS=${CI_STATUS:-unknown}
    case "$CI_STATUS" in
      "failed")
        echo -e "   ${RED}❌ 测试失败${NC}"
        ;;
      "skipped"|"unknown")
        echo -e "   ${YELLOW}⚠️ 测试未运行${NC}"
        ;;
      "passed")
        echo -e "   ${GREEN}✅ 测试通过${NC}"
        ;;
    esac
    
    # 如果有阻塞原因，显示它们
    if [[ ${#MERGE_BLOCKERS[@]} -gt 0 ]]; then
      echo -e "\n${YELLOW}⚠️ 自动合并被阻塞：${NC}"
      for blocker in "${MERGE_BLOCKERS[@]}"; do
        echo -e "   • $blocker"
      done
      CAN_AUTO_MERGE=false
    fi
    
  else
    # AI评审建议不要自动合并
    echo -e "${YELLOW}⚠️ AI评审建议不执行自动合并${NC}"
    CAN_AUTO_MERGE=false
    
    if [[ ${#MERGE_BLOCKERS[@]} -gt 0 ]]; then
      echo -e "${YELLOW}原因：${NC}"
      for blocker in "${MERGE_BLOCKERS[@]}"; do
        echo -e "   • $blocker"
      done
    fi
  fi
  
  
  # 步骤3.5：执行自动合并
  if [[ "$CAN_AUTO_MERGE" == "true" ]]; then
    echo -e "\n${GREEN}✅ 所有检查通过，执行自动合并...${NC}"
    
    MERGE_CMD=$(cat <<EOF
请使用 Gitee MCP 工具执行以下操作：

1. 首先合并PR - 使用 ${MCP_TOOL_MERGE}：
   - owner: ${REPO%%/*}
   - repo: ${REPO##*/}
   - number: ${PR_NUMBER}
   - merge_method: ${MERGE_METHOD}
   - title: 自动合并：低风险PR
   - description: 通过自动化管道验证：风险等级低，所有测试通过

2. 如果合并成功，添加评论 - 使用 ${MCP_TOOL_COMMENT}：
   评论内容：
   ## ✅ 自动合并完成
   
   此PR已通过自动化评审并成功合并！
   
   ### 📊 评审结果
   - **风险等级**: 🟢 低风险
   - **评审得分**: ${REVIEW_SCORE:-85}分  
   - **合并方式**: ${MERGE_METHOD}
   - **合并时间**: $(date '+%Y-%m-%d %H:%M:%S')
   
   ### ✅ 验证通过项目
   - 代码评审通过
   - 测试验证通过  
   - 无敏感路径变更
   - 无合并冲突
   - 改动行数符合要求(${LINE_CHANGES:-0} < ${MAX_LINES_FOR_AUTO_MERGE})
   
   ### 🤖 详细评审报告
   $(if [[ -f "$REVIEW_LOG" ]] && grep -q "【第二部分：Markdown评审报告】" "$REVIEW_LOG"; then
     sed -n '/【第二部分：Markdown评审报告】/,$p' "$REVIEW_LOG" | tail -n +2 | head -20
   else
     echo "评审系统确认此PR为低风险变更，符合自动合并条件。"
   fi)
   
   ---
   *🚀 由 PR Sentinel 自动化系统执行*

请用中文确认执行结果。
EOF
)
    
    set +e
    echo "$MERGE_CMD" | claude -p "执行合并并评论 ${REPO}#${PR_NUMBER}" --permission-mode bypassPermissions 2>&1 | tee /tmp/merge_exec.log
    MERGE_PIPELINE_CODE=${PIPESTATUS[1]}
    set -e
    
    if grep -qi "成功\|success\|merged\|已合并" /tmp/merge_exec.log && [[ $MERGE_PIPELINE_CODE -eq 0 ]]; then
      MERGE_EXECUTED=true
      MERGE_RESULT="✅ 自动合并成功"
      echo -e "${GREEN}🎉 PR已自动合并成功！${NC}"
      
    else
      MERGE_RESULT="❌ 合并失败"
      echo -e "${RED}❌ 自动合并失败（退出码：$MERGE_PIPELINE_CODE）${NC}"
    fi
  else
    echo -e "\n${YELLOW}⚠️ 不满足自动合并条件${NC}"
    MERGE_RESULT="⏸️ 需人工处理"
    if [[ ${#MERGE_BLOCKERS[@]} -gt 0 ]]; then
      echo -e "${RED}阻塞原因：${NC}"
      for blocker in "${MERGE_BLOCKERS[@]}"; do
        echo -e "   • $blocker"
      done
    fi
  fi
  
elif [[ "$RISK_LEVEL" == "低风险" ]] && [[ "$AUTO_MERGE_IF_LOW_RISK" != "true" ]]; then
  echo -e "${YELLOW}ℹ️ 低风险但自动合并已禁用${NC}"
  MERGE_RESULT="📋 仅评审"
else
  echo -e "${YELLOW}⚠️ 风险等级：${RISK_LEVEL}，不执行自动合并${NC}"
  MERGE_RESULT="⚠️ 风险过高"
fi

echo -e "\n${BLUE}合并决策：${MERGE_RESULT}${NC}"

# 计算评审分数（优先使用AI提供的分数）
calculate_score() {
  # 如果AI已经提供了评分，直接使用
  if [[ -n "$REVIEW_SCORE" ]] && [[ "$REVIEW_SCORE" -gt 0 ]]; then
    echo "$REVIEW_SCORE"
    return
  fi
  
  # 如果有质量分数，使用质量分数
  if [[ -n "$QUALITY_SCORE" ]] && [[ "$QUALITY_SCORE" -gt 0 ]]; then
    echo "$QUALITY_SCORE"
    return
  fi
  
  # 否则使用传统计算方式作为后备
  local base_score=100
  local final_score=$base_score
  
  # 根据风险等级调整分数
  case "$RISK_LEVEL" in
    "低风险")
      final_score=$((base_score - 10))  # 低风险：90分起
      ;;
    "中等风险")
      final_score=$((base_score - 30))  # 中等风险：70分起
      ;;
    "高风险")
      final_score=$((base_score - 50))  # 高风险：50分起
      ;;
    *)
      final_score=$((base_score - 40))  # 未知风险：60分起
      ;;
  esac
  
  # 根据文件数量调整（文件越多扣分越多）
  if [[ -n "$FILE_COUNT" ]] && [[ "$FILE_COUNT" -gt 0 ]]; then
    if [[ "$FILE_COUNT" -gt 20 ]]; then
      final_score=$((final_score - 10))
    elif [[ "$FILE_COUNT" -gt 10 ]]; then
      final_score=$((final_score - 5))
    fi
  fi
  
  # 根据合并状态加分
  if [[ "$MERGE_EXECUTED" == "true" ]]; then
    final_score=$((final_score + 10))
  fi
  
  # 根据测试结果调整
  if [[ "$CAN_AUTO_MERGE" == "true" ]]; then
    final_score=$((final_score + 5))
  fi
  
  # 确保分数在0-100范围内
  if [[ $final_score -gt 100 ]]; then
    final_score=100
  elif [[ $final_score -lt 0 ]]; then
    final_score=0
  fi
  
  echo $final_score
}

# 计算最终分数
REVIEW_SCORE=$(calculate_score)
echo -e "\n${BLUE}评审得分：${REVIEW_SCORE}分${NC}"

# 初始化时间戳
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# 步骤4：发布PR评论（只在未执行自动合并时发布）
echo -e "\n${YELLOW}步骤 4: 发布PR评论...${NC}"

# 如果评审失败，发布失败通知
if [[ "$REVIEW_FAILED" == "true" ]]; then
  echo -e "${RED}❌ 评审失败，发布失败通知到PR${NC}"
  
  # 生成失败通知评论
  COMMENT_BODY=$(cat <<EOF
## ❌ 代码评审失败

评审系统无法完成此PR的自动评审。

**失败原因：**
- Claude API调用失败或返回空内容
- 请检查系统日志了解详细错误信息

**建议操作：**
1. 手动重新触发评审
2. 联系系统管理员检查服务状态
3. 查看日志文件：${DEBUG_LOG}

---
*自动化评审系统 v3.0 - 评审失败*
EOF
)
  
  # 发布失败评论到PR
  COMMENT_CMD="使用 ${MCP_TOOL_COMMENT} 发布评论到 ${REPO} PR #${PR_NUMBER}：

${COMMENT_BODY}"
  
  # 捕获Claude输出并检查实际执行结果
  CLAUDE_OUTPUT=$(echo "$COMMENT_CMD" | claude -p "发布PR失败通知 ${REPO}#${PR_NUMBER}" --permission-mode bypassPermissions 2>&1)
  CLAUDE_EXIT_CODE=$?
  
  # 记录Claude输出到调试日志
  log_debug "Claude CLI 退出码: $CLAUDE_EXIT_CODE"
  log_debug "Claude CLI 输出: $CLAUDE_OUTPUT"
  
  # 检查退出码和输出内容，确认评论是否真正发布成功
  if [ $CLAUDE_EXIT_CODE -eq 0 ] && [[ "$CLAUDE_OUTPUT" =~ "评论发布成功" || "$CLAUDE_OUTPUT" =~ "comment.*success" || "$CLAUDE_OUTPUT" =~ "已发布" || "$CLAUDE_OUTPUT" =~ "created" ]]; then
    echo -e "${GREEN}✅ 失败通知已发布${NC}"
    PR_COMMENT_STATUS="✅ 失败通知已发布"
  else
    echo -e "${RED}❌ 失败通知发布失败${NC}"
    echo -e "${RED}[ERROR] 失败原因: $CLAUDE_OUTPUT${NC}"
    PR_COMMENT_STATUS="❌ 通知发布失败"
    log_error "PR评论发布失败: $CLAUDE_OUTPUT"
  fi
  
# 如果已经执行了自动合并，合并时已经发布了评论，这里跳过
elif [[ "$MERGE_EXECUTED" == "true" ]]; then
  echo -e "${GREEN}✅ 已在合并时发布评论${NC}"
  PR_COMMENT_STATUS="✅ 已发布"
else
  # 生成评论内容（智能提取Markdown评审报告）
  MARKDOWN_SECTION=""
  if [[ -f "$REVIEW_LOG" ]]; then
    log_debug "开始从评审日志提取Markdown报告: $REVIEW_LOG"
    
    # 尝试多种方式提取Markdown报告
    # 方法1: 查找"【第二部分：Markdown评审报告】"标记
    if grep -q "【第二部分：Markdown评审报告】" "$REVIEW_LOG"; then
      MARKDOWN_SECTION=$(sed -n '/【第二部分：Markdown评审报告】/,$p' "$REVIEW_LOG" | tail -n +2)
      log_debug "使用方法1提取到内容长度: ${#MARKDOWN_SECTION}"
    fi
    
    # 方法2: 如果方法1没有内容，查找"## "开头的Markdown内容
    if [[ -z "$MARKDOWN_SECTION" ]]; then
      MARKDOWN_SECTION=$(grep -A 1000 "^## " "$REVIEW_LOG" | head -1000)
      log_debug "使用方法2提取到内容长度: ${#MARKDOWN_SECTION}"
    fi
    
    # 方法3: 如果方法2也没有内容，查找"# "开头的Markdown内容  
    if [[ -z "$MARKDOWN_SECTION" ]]; then
      MARKDOWN_SECTION=$(grep -A 1000 "^# " "$REVIEW_LOG" | head -1000)
      log_debug "使用方法3提取到内容长度: ${#MARKDOWN_SECTION}"
    fi
    
    # 方法4: 如果以上都没有，使用整个评审输出（去除JSON部分）
    if [[ -z "$MARKDOWN_SECTION" ]]; then
      # 查找并跳过JSON部分（```json 到 ``` 之间的内容）
      MARKDOWN_SECTION=$(sed '/```json/,/```/d' "$REVIEW_LOG")
      log_debug "使用方法4提取到内容长度: ${#MARKDOWN_SECTION}"
    fi
    
    # 如果还是没有内容，记录错误并使用原始评审结果
    if [[ -z "$MARKDOWN_SECTION" ]]; then
      log_error "无法提取Markdown报告，使用原始评审结果"
      MARKDOWN_SECTION=$(cat "$REVIEW_LOG")
    fi
    
    log_debug "最终提取的Markdown内容预览: $(echo "$MARKDOWN_SECTION" | head -3 | tr '\n' ' ')"
  else
    log_error "评审日志文件不存在: $REVIEW_LOG"
    MARKDOWN_SECTION="评审日志文件不存在，无法生成评论。"
  fi
  
  # 构建完整的评论内容，确保格式适合Gitee展示
  COMMENT_BODY=$(cat <<EOF
## 🤖 AI代码评审报告

${MARKDOWN_SECTION}

---

### 📊 评审汇总
- **风险等级**: ${RISK_LEVEL}
- **评审得分**: ${REVIEW_SCORE:-未知}分
- **合并决策**: ${MERGE_RESULT}

### 🛠️ 系统信息
- **评审时间**: $(date '+%Y-%m-%d %H:%M:%S')
- **评审系统**: PR Sentinel v3.0 (powered by Claude AI)
- **MCP工具**: Gitee Integration

> 💡 如有疑问，请查看 [评审标准文档](${REPO}/blob/main/review/) 或联系项目维护者
EOF
)

  # 发布评论到PR
  COMMENT_CMD="使用 ${MCP_TOOL_COMMENT} 发布评论到 ${REPO} PR #${PR_NUMBER}：

${COMMENT_BODY}"

  # 捕获Claude输出并检查实际执行结果
  CLAUDE_OUTPUT=$(echo "$COMMENT_CMD" | claude -p "发布PR评论 ${REPO}#${PR_NUMBER}" --permission-mode bypassPermissions 2>&1)
  CLAUDE_EXIT_CODE=$?

  # 记录Claude输出到调试日志
  log_debug "Claude CLI 退出码: $CLAUDE_EXIT_CODE"
  log_debug "Claude CLI 输出: $CLAUDE_OUTPUT"

  # 检查退出码和输出内容，确认评论是否真正发布成功
  if [ $CLAUDE_EXIT_CODE -eq 0 ] && [[ "$CLAUDE_OUTPUT" =~ "评论发布成功" || "$CLAUDE_OUTPUT" =~ "comment.*success" || "$CLAUDE_OUTPUT" =~ "已发布" || "$CLAUDE_OUTPUT" =~ "created" ]]; then
    echo -e "${GREEN}✅ PR评论发布成功${NC}"
    PR_COMMENT_STATUS="✅ 已发布"
  else
    echo -e "${RED}❌ PR评论发布失败${NC}"
    echo -e "${RED}[ERROR] 失败原因: $CLAUDE_OUTPUT${NC}"
    PR_COMMENT_STATUS="❌ 发布失败"
    log_error "PR评论发布失败: $CLAUDE_OUTPUT"
  fi
fi

# 步骤5：发送钉钉通知
echo -e "\n${YELLOW}步骤 5: 发送钉钉通知...${NC}"

# 检查是否启用钉钉通知
if [[ "$ENABLE_DINGTALK_NOTIFY" != "true" ]]; then
  echo -e "${YELLOW}⏭️ 钉钉通知已禁用，跳过${NC}"
else
  # 构建钉钉消息（中文版）
  # 首先检查评审是否失败
  if [[ "$REVIEW_FAILED" == "true" ]]; then
    # 评审失败的通知
    MESSAGE=$(cat <<EOF
{
  "msgtype": "markdown",
  "markdown": {
    "title": "❌ PR评审失败：${REPO}#${PR_NUMBER}",
    "text": "## ⚠️ 评审执行失败\n\n**项目信息**\n- 仓库：${REPO}\n- PR编号：#${PR_NUMBER}\n- 失败时间：${TIMESTAMP}\n\n**错误信息**\n- 状态：❌ 评审失败\n- 原因：Claude API调用失败或返回空内容\n- 错误详情：请检查日志文件\n\n**建议操作**\n- 检查Claude API状态\n- 查看详细日志：${DEBUG_LOG}\n- 手动重新触发评审\n\n**相关链接**\n[查看PR](https://gitee.com/${REPO}/pulls/${PR_NUMBER})\n\n---\n*自动化管道 v3.0 - 评审失败*"
  }
}
EOF
)
  elif [[ "$MERGE_EXECUTED" == "true" ]]; then
    # 自动合并成功的通知
    MESSAGE=$(cat <<EOF
{
  "msgtype": "markdown",
  "markdown": {
    "title": "✅ PR自动合并：${REPO}#${PR_NUMBER}",
    "text": "## 🎉 自动合并完成\n\n**项目信息**\n- 仓库：${REPO}\n- PR编号：#${PR_NUMBER}\n- 合并时间：${TIMESTAMP}\n\n**评审结果**\n- 风险等级：${RISK_EMOJI} **${RISK_LEVEL}**\n- 测试状态：✅ 通过\n- 合并状态：✅ 已成功合并\n- 合并方式：${MERGE_METHOD}\n\n**验证项目**\n- ✅ 代码评审通过（低风险）\n- ✅ 测试验证通过\n- ✅ 无敏感路径变更\n- ✅ 无合并冲突\n\n**查看详情**\n[打开PR](https://gitee.com/${REPO}/pulls/${PR_NUMBER})\n\n---\n*自动化管道 v3.0 - 自动合并*"
  }
}
EOF
)
  else
    # 正常评审完成但未自动合并的通知
    # 构建阻塞原因说明
    BLOCKER_TEXT=""
    if [[ ${#MERGE_BLOCKERS[@]} -gt 0 ]]; then
      BLOCKER_TEXT="\n\n**未自动合并原因**\n"
      for blocker in "${MERGE_BLOCKERS[@]}"; do
        BLOCKER_TEXT="${BLOCKER_TEXT}- ${blocker}\n"
      done
    fi
    
    # 构建主要问题说明（如果有）
    MAIN_ISSUES_TEXT=""
    if [[ -n "$CRITICAL_ISSUES" ]] && [[ "$CRITICAL_ISSUES" -gt 0 ]]; then
      MAIN_ISSUES_TEXT="\n\n**发现的问题**\n- 严重问题：${CRITICAL_ISSUES}个"
    fi
    if [[ -n "$MAJOR_ISSUES" ]] && [[ "$MAJOR_ISSUES" -gt 0 ]]; then
      if [[ -z "$MAIN_ISSUES_TEXT" ]]; then
        MAIN_ISSUES_TEXT="\n\n**发现的问题**"
      fi
      MAIN_ISSUES_TEXT="${MAIN_ISSUES_TEXT}\n- 主要问题：${MAJOR_ISSUES}个"
    fi
    
    MESSAGE=$(cat <<EOF
{
  "msgtype": "markdown",
  "markdown": {
    "title": "PR评审完成：${REPO}#${PR_NUMBER}",
    "text": "## 🤖 代码评审报告\n\n**项目信息**\n- 仓库：${REPO}\n- PR编号：#${PR_NUMBER}\n- 评审时间：${TIMESTAMP}\n\n**评审结果**\n- 风险等级：${RISK_EMOJI} **${RISK_LEVEL}**\n- 评审状态：✅ 已完成\n- 合并决策：${MERGE_RESULT}${MAIN_ISSUES_TEXT}${BLOCKER_TEXT}\n\n**后续操作**\n- [查看详细评论](https://gitee.com/${REPO}/pulls/${PR_NUMBER})\n- 根据评审建议修改代码\n\n---\n*自动化管道 v3.0*"
  }
}
EOF
)
  fi

  # 发送通知
  RESPONSE=$(curl -s -X POST "$DINGTALK_WEBHOOK_URL" \
    -H "Content-Type: application/json" \
    -d "$MESSAGE")

  if echo "$RESPONSE" | grep -q '"errcode":0'; then
    echo -e "${GREEN}✅ 钉钉通知发送成功！${NC}"
  else
    echo -e "${RED}❌ 钉钉通知发送失败：${NC}"
    echo "$RESPONSE"
  fi
fi

# 步骤6：显示总结
echo
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}📝 步骤 6: 执行总结${NC}"
echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo
echo -e "${BLUE}执行结果：${NC}"
echo -e "• 代码评审：✅ 完成（中文）"
echo -e "• 风险等级：${RISK_EMOJI} ${RISK_LEVEL} (评分: ${RISK_SCORE:-N/A})"
echo -e "• 代码质量：${QUALITY_SCORE:-N/A}分"
echo -e "• 评审得分：${REVIEW_SCORE}分"

# 显示问题统计
if [[ -n "$CRITICAL_ISSUES" ]] && [[ "$CRITICAL_ISSUES" -gt 0 ]]; then
  echo -e "• 严重问题：${RED}${CRITICAL_ISSUES}个${NC}"
fi
if [[ -n "$MAJOR_ISSUES" ]] && [[ "$MAJOR_ISSUES" -gt 0 ]]; then
  echo -e "• 主要问题：${YELLOW}${MAJOR_ISSUES}个${NC}"
fi

# 显示测试和代码风格信息
if [[ -n "$TEST_COVERAGE" ]]; then
  echo -e "• 测试覆盖：${TEST_COVERAGE}"
fi
if [[ -n "$CODE_STYLE" ]]; then
  echo -e "• 代码风格：${CODE_STYLE}"
fi

echo -e "• PR评论：${PR_COMMENT_STATUS}"

if [[ "$RISK_LEVEL" == "低风险" ]] && [[ "$AUTO_MERGE_IF_LOW_RISK" == "true" ]]; then
  echo -e "• 测试验证：${CAN_AUTO_MERGE:+✅ 通过}${CAN_AUTO_MERGE:-❌ 未通过}"
  echo -e "• 自动合并：${MERGE_RESULT}"
fi

if [[ "$ENABLE_DINGTALK_NOTIFY" == "true" ]]; then
  echo -e "• 钉钉通知：✅ 已发送"
else
  echo -e "• 钉钉通知：⏭️ 已禁用"
fi

if [[ ${#MERGE_BLOCKERS[@]} -gt 0 ]]; then
  echo
  echo -e "${YELLOW}需要解决的问题：${NC}"
  for blocker in "${MERGE_BLOCKERS[@]}"; do
    echo -e "   • ${blocker}"
  done
fi

echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

# 保存评审报告
REPORT_FILE="$SCRIPT_DIR/logs/reviews/report-${REPO//\//-}-pr${PR_NUMBER}-$(date +%Y%m%d-%H%M%S).txt"
{
  echo "评审报告 - ${REPO}#${PR_NUMBER}"
  echo "时间：${TIMESTAMP}"
  echo "风险等级：${RISK_LEVEL}"
  echo "评审得分：${REVIEW_SCORE}分"
  echo "---"
  cat "$REVIEW_LOG"
} > "$REPORT_FILE"

echo
echo -e "${BLUE}📄 详细报告已保存到：${REPORT_FILE}${NC}"

# 记录执行总结到调试日志
log_info "========== 执行总结 =========="
log_info "仓库: $REPO"
log_info "PR编号: $PR_NUMBER"
log_info "风险等级: $RISK_LEVEL"
log_info "评审得分: ${REVIEW_SCORE}分"
log_info "合并状态: $MERGE_RESULT"
log_info "评审日志: $REVIEW_LOG"
log_info "调试日志: $DEBUG_LOG"
log_info "========== 脚本执行完成 =========="

# 保存评分记录
if [[ "$ENABLE_SCORE_RECORDING" == "true" ]]; then
  echo -e "\n${YELLOW}保存评分记录...${NC}"
  
  # 确保score目录存在
  mkdir -p "$SCORE_DIR"
  
  # 使用统一的评分记录文件
  SCORE_FILE="${SCORE_DIR}/all_reviews.txt"
  REVIEW_TIME=$(date '+%Y-%m-%d %H:%M:%S')
  
  # 确定合并状态文字
  if [[ "$MERGE_EXECUTED" == "true" ]]; then
    MERGE_STATUS="已合并"
  elif [[ "$RISK_LEVEL" == "低风险" ]] && [[ "$AUTO_MERGE_IF_LOW_RISK" != "true" ]]; then
    MERGE_STATUS="待处理"
  elif [[ "$RISK_LEVEL" != "低风险" ]]; then
    MERGE_STATUS="未合并"
  else
    MERGE_STATUS="待处理"
  fi
  
  # 如果文件不存在，先创建并添加头部
  if [[ ! -f "$SCORE_FILE" ]]; then
    echo "# PR评审记录汇总" > "$SCORE_FILE"
    echo "# PR编号|标题|提交人|风险等级|评分|合并状态|评审时间|仓库" >> "$SCORE_FILE"
    echo "#=============================================================" >> "$SCORE_FILE"
  fi
  
  # 添加评审记录（处理特殊字符，并包含仓库信息）
  RECORD_LINE="#${PR_NUMBER}|${PR_TITLE//|/_}|${PR_AUTHOR//|/_}|${RISK_LEVEL}|${REVIEW_SCORE}|${MERGE_STATUS}|${REVIEW_TIME}|${REPO//|/_}"
  echo "$RECORD_LINE" >> "$SCORE_FILE"
  
  echo -e "${GREEN}✅ 评分记录已保存到：${SCORE_FILE}${NC}"
fi